This tutorial introduces conceptual maps — a family of visualisation techniques that represent semantic relationships between words or concepts as a spatial network, where proximity encodes similarity. Conceptual maps have become an increasingly popular tool in corpus linguistics, cognitive linguistics, and digital humanities for exploring how words cluster into meaning domains, how concepts relate across registers or time periods, and how semantic structure can be revealed from large bodies of text (Schneider 2024).
The key idea is simple: words that tend to appear in similar contexts — or that share distributional properties — are semantically related. By converting this distributional information into a similarity matrix and then applying a spring-layout algorithm (or a related graph-drawing method), we can produce two-dimensional maps where semantically close words cluster together and semantically distant words are pushed apart. The maps are not just aesthetically appealing; they are analytically informative, revealing lexical fields, semantic neighbourhoods, and conceptual organisation that would be invisible in a table of numbers.
Gerold Schneider and colleagues have been prominent advocates of conceptual maps as a practical and accessible visualisation tool for linguists (Schneider 2024), making the case that spring-layout graphs offer a more interpretively transparent alternative to purely statistical dimensionality-reduction techniques such as PCA or MDS.
This tutorial assumes familiarity with:
stringrggplot2 fundamentalsFamiliarity with Network Analysis is helpful but not required.
By the end of this tutorial you will be able to:
igraph, ggraph, and qgraphMartin Schweinberger. 2026. Conceptual Maps in R. The Language Technology and Data Analysis Laboratory (LADAL), The University of Queensland, Australia. url: https://ladal.edu.au/tutorials/conceptmaps/conceptmaps.html (Version 3.1.1). doi: 10.5281/zenodo.19332087.
What you will learn: The conceptual and technical foundations of conceptual maps; how they differ from related visualisations; and the algorithmic principles behind spring-layout graphs
The distributional hypothesis — one of the foundational principles of computational linguistics — states that words occurring in similar contexts tend to have similar meanings (Firth 1957; Harris 1954). If we count how often words co-occur with each other (or how often they appear in similar document contexts), we can construct a similarity matrix that numerically encodes semantic relatedness.
A conceptual map turns this matrix into a visual space. Words (or concepts, documents, or any linguistic units) become nodes in a graph, and their pairwise similarities become edge weights. A spring-layout algorithm then positions the nodes so that:
The result is a two-dimensional spatial arrangement where the geometry of the map encodes semantic structure — clusters correspond to lexical fields, bridges correspond to polysemous or connecting words, and peripheral nodes correspond to domain-specific or infrequent terms.
The Fruchterman–Reingold algorithm (Fruchterman and Reingold 1991) — the most widely used spring-layout method — models the graph as a physical system:
This physical analogy gives the algorithm its name. The final layout minimises a global energy function, placing highly connected nodes near each other and sparsely connected nodes far apart.
| Method | What it preserves | Strengths | Limitations |
|---|---|---|---|
| Spring layout (Fruchterman-Reingold) | Graph topology and edge weights | Intuitive clusters; interactive via igraph/ggraph |
Layout is stochastic (set a seed!); does not preserve exact distances |
| Classical MDS | Pairwise distances as faithfully as possible | Mathematically principled; deterministic | Less visually clear for dense graphs |
| t-SNE / UMAP | Local neighbourhood structure | Excellent for high-dimensional embeddings | Hyperparameter-sensitive; not directly available in base R |
| PCA (biplot) | Maximum variance directions | Shows axes of variation | Axes not directly interpretable as semantic dimensions |
For conceptual maps used in linguistic research, spring layout (with igraph/ggraph) or qgraph are the most common choices. MDS is a useful comparison baseline and is covered in the Dimension Reduction tutorial.
This tutorial covers three methods for constructing the similarity matrix that feeds into the map:
Route 1 — Co-occurrence matrix: Count how often pairs of target words appear within the same window of text (e.g. within 5 words of each other). Convert raw counts to a similarity score (e.g. pointwise mutual information, PMI). Best for exploring the immediate lexical context of a set of target words.
Route 2 — Document-term matrix (TF-IDF): Represent each word as a vector of TF-IDF weights across documents. Compute cosine similarity between word vectors. Best for exploring topical or register-level semantic relationships.
Route 3 — Word embeddings: Use pre-trained dense word vectors (e.g. GloVe) in which each word is represented as a 50–300 dimensional vector. Compute cosine similarity. Best for capturing broad distributional semantics trained on large corpora.
Which statement best describes what a spring-layout algorithm does when drawing a conceptual map?
c) It arranges words so that strongly similar pairs are pulled together and dissimilar pairs are pushed apart, simulating a physical spring system
The Fruchterman–Reingold spring-layout algorithm models the graph as a physical system of springs (attractive forces between connected nodes) and repulsive charges (between all node pairs). The layout minimises a global energy function, naturally grouping semantically related words into clusters. Options (a) and (b) describe simpler but semantically uninformative arrangements. Option (d) describes PCA, which is a separate dimensionality-reduction technique that does not use graph topology.
# Run once — comment out after installation
install.packages("tidyverse")
install.packages("tidytext")
install.packages("gutenbergr")
install.packages("igraph")
install.packages("ggraph")
install.packages("qgraph")
install.packages("widyr")
install.packages("Matrix")
install.packages("smacof")
install.packages("text2vec")
install.packages("flextable")
install.packages("ggrepel")
install.packages("RColorBrewer")
install.packages("viridis")options(stringsAsFactors = FALSE)
options("scipen" = 100, "digits" = 12)
library(tidyverse)
library(tidytext)
library(gutenbergr)
library(igraph)
library(ggraph)
library(qgraph)
library(widyr)
library(Matrix)
library(smacof)
library(text2vec)
library(flextable)
library(ggrepel)
library(RColorBrewer)
library(viridis)What you will learn: How to download and prepare a real corpus, construct a toy dataset for experimentation, and understand what data structure feeds into a conceptual map
Throughout this tutorial we use Jane Austen’s Sense and Sensibility (1811), downloaded from Project Gutenberg. This novel provides a rich vocabulary of emotion, social relations, and domestic life — an ideal domain for exploring semantic clustering.
# Download Sense and Sensibility from Project Gutenberg
# gutenberg_id 161
sns <- gutenberg_download(161, mirror = "http://mirrors.xmission.com/gutenberg/")
# Tokenise to words, remove stop words and punctuation
data("stop_words") # built-in tidytext stop word list
sns_words <- sns |>
# add a paragraph/chunk ID (every 10 lines = one context window)
dplyr::mutate(chunk = ceiling(row_number() / 10)) |>
tidytext::unnest_tokens(word, text) |>
dplyr::anti_join(stop_words, by = "word") |>
dplyr::filter(str_detect(word, "^[a-z]+$"), # letters only
str_length(word) > 2) # at least 3 charactersTotal tokens (after cleaning): 35573 Unique word types: 5760 Number of 10-line chunks: 1268 We focus on a curated set of emotion and social relation words that are frequent enough to produce stable co-occurrence counts. This makes the resulting map interpretable and pedagogically clear.
# Target vocabulary: emotion, character, social, and moral terms
target_words <- c(
# emotions
"love", "hope", "fear", "joy", "pain", "grief", "happiness",
"sorrow", "pleasure", "affection", "passion", "anxiety", "distress",
"comfort", "delight", "misery", "pride", "shame", "anger",
# social relations
"friendship", "marriage", "family", "sister", "mother", "heart",
"feeling", "sensibility", "sense", "honour", "duty",
# character
"beauty", "elegance", "worth", "character", "spirit", "temper"
)
cat("Target vocabulary size:", length(target_words), "\n")Target vocabulary size: 36 For readers who want a smaller, fully self-contained example to experiment with, here is a toy co-occurrence matrix for 12 words across three semantic domains. You can use this to test code without downloading the Gutenberg corpus.
# Toy similarity matrix: 12 words, three domains
# (body parts, emotions, social roles)
toy_words <- c("heart", "hand", "eye", "mind",
"joy", "fear", "love", "grief",
"friend", "mother", "sister", "husband")
set.seed(42)
# Build a structured similarity matrix with within-domain similarity > between-domain
n <- length(toy_words)
toy_sim <- matrix(0.1, nrow = n, ncol = n,
dimnames = list(toy_words, toy_words))
diag(toy_sim) <- 1
# Within-domain similarities (higher)
body <- 1:4; emotion <- 5:8; social <- 9:12
for (grp in list(body, emotion, social)) {
for (i in grp) for (j in grp) {
if (i != j) toy_sim[i, j] <- runif(1, 0.45, 0.75)
}
}
# Cross-domain: heart <-> emotion (polysemy)
toy_sim["heart", emotion] <- toy_sim[emotion, "heart"] <- runif(4, 0.3, 0.5)
# Ensure symmetry
toy_sim <- (toy_sim + t(toy_sim)) / 2
diag(toy_sim) <- 1
cat("Toy similarity matrix (first 6 rows/cols):\n")Toy similarity matrix (first 6 rows/cols):round(toy_sim[1:6, 1:6], 2) heart hand eye mind joy fear
heart 1.00 0.71 0.70 0.60 0.30 0.34
hand 0.71 1.00 0.57 0.60 0.10 0.10
eye 0.70 0.57 1.00 0.66 0.10 0.10
mind 0.60 0.60 0.66 1.00 0.10 0.10
joy 0.30 0.10 0.10 0.10 1.00 0.73
fear 0.34 0.10 0.10 0.10 0.73 1.00What you will learn: How to count word co-occurrences within context windows, convert counts to PMI similarity scores, threshold the matrix to build a sparse graph, and visualise the result with igraph and ggraph
A co-occurrence matrix records how many times each pair of target words appears within the same context window — here, within the same 10-line chunk of text. Words that frequently share contexts are semantically related: they tend to appear in the same scenes, describe the same characters, or participate in the same semantic frame.
Raw counts are converted to Pointwise Mutual Information (PMI):
\[\text{PMI}(w_1, w_2) = \log \frac{P(w_1, w_2)}{P(w_1) \cdot P(w_2)}\]
PMI measures how much more often two words co-occur than would be expected by chance if they were independent. Positive PMI values indicate attraction; negative values (rare in filtered matrices) indicate repulsion. We use positive PMI (PPMI), which floors negative values at zero.
# Keep only target words, then count pairwise chunk co-occurrences
sns_target <- sns_words |>
dplyr::filter(word %in% target_words)
# Count co-occurrences within chunks using widyr::pairwise_count
cooc_counts <- sns_target |>
widyr::pairwise_count(word, chunk, sort = TRUE, upper = FALSE)
cat("Total co-occurrence pairs found:", nrow(cooc_counts), "\n")Total co-occurrence pairs found: 336 head(cooc_counts, 10)# A tibble: 10 × 3
item1 item2 n
<chr> <chr> <dbl>
1 sister mother 26
2 heart mother 22
3 sister heart 18
4 mother affection 18
5 sister hope 16
6 family mother 15
7 sister pleasure 14
8 mother hope 14
9 sister love 14
10 heart love 14# Total chunk appearances per word (marginal counts)
word_totals <- sns_target |>
dplyr::count(word, name = "n_word")
total_chunks <- n_distinct(sns_target$chunk)
# Join marginals and compute PMI
cooc_pmi <- cooc_counts |>
dplyr::rename(w1 = item1, w2 = item2, n_cooc = n) |>
dplyr::left_join(word_totals, by = c("w1" = "word")) |>
dplyr::rename(n_w1 = n_word) |>
dplyr::left_join(word_totals, by = c("w2" = "word")) |>
dplyr::rename(n_w2 = n_word) |>
dplyr::mutate(
p_cooc = n_cooc / total_chunks,
p_w1 = n_w1 / total_chunks,
p_w2 = n_w2 / total_chunks,
pmi = log2(p_cooc / (p_w1 * p_w2)),
ppmi = pmax(pmi, 0) # floor at 0 (positive PMI only)
) |>
dplyr::filter(ppmi > 0) # keep only pairs with positive association
cat("Pairs with positive PMI:", nrow(cooc_pmi), "\n")Pairs with positive PMI: 174 For a readable map, we retain only the strongest edges. Keeping all pairs produces a dense hairball; thresholding to the top edges reveals the underlying cluster structure.
# Keep top edges by PPMI — enough for a readable map
ppmi_threshold <- quantile(cooc_pmi$ppmi, 0.60) # top 40% of pairs
cooc_edges <- cooc_pmi |>
dplyr::filter(ppmi >= ppmi_threshold) |>
dplyr::select(from = w1, to = w2, weight = ppmi)
# Build igraph object
g_cooc <- igraph::graph_from_data_frame(cooc_edges, directed = FALSE)
# Add semantic domain as a node attribute for colouring
# Using case_when avoids fragile rep() counts that break if target_words changes
domain_lookup <- tibble::tibble(word = target_words) |>
dplyr::mutate(domain = dplyr::case_when(
word %in% c("love", "hope", "fear", "joy", "pain", "grief", "happiness",
"sorrow", "pleasure", "affection", "passion", "anxiety",
"distress", "comfort", "delight", "misery", "pride",
"shame", "anger") ~ "Emotion",
word %in% c("friendship", "marriage", "family", "sister", "mother",
"heart", "feeling", "sensibility", "sense", "honour",
"duty") ~ "Social",
TRUE ~ "Character"
))
domain_vec <- domain_lookup$domain[match(V(g_cooc)$name, domain_lookup$word)]
V(g_cooc)$domain <- domain_vec
cat("Nodes in graph:", vcount(g_cooc), "\n")Nodes in graph: 33 cat("Edges in graph:", ecount(g_cooc), "\n")Edges in graph: 70 igraphset.seed(2024) # spring layout is stochastic — always set a seed for reproducibility
# Compute Fruchterman-Reingold layout
lay <- igraph::layout_with_fr(g_cooc, weights = E(g_cooc)$weight)
# Colour palette by domain
domain_cols <- c("Emotion" = "#E07B54", "Social" = "#5B8DB8", "Character" = "#6BAF7A")
node_cols <- domain_cols[V(g_cooc)$domain]
# Plot
par(mar = c(1, 1, 2, 1))
plot(
g_cooc,
layout = lay,
vertex.color = node_cols,
vertex.size = 12,
vertex.label = V(g_cooc)$name,
vertex.label.cex = 0.75,
vertex.label.color = "black",
vertex.frame.color = "white",
edge.width = E(g_cooc)$weight * 1.5,
edge.color = adjustcolor("gray50", alpha.f = 0.6),
main = "Conceptual Map: Sense and Sensibility\n(Co-occurrence + PPMI, Fruchterman-Reingold layout)"
)
legend("bottomleft",
legend = names(domain_cols),
fill = domain_cols,
border = "white",
bty = "n",
cex = 0.85)
The Fruchterman–Reingold spring-layout algorithm is stochastic — it starts from a random initialisation and may produce a different spatial arrangement each run. Always use set.seed() before computing the layout so your maps are reproducible. Different seeds may rotate or mirror the map but should preserve the cluster structure.
ggraphggraph integrates spring-layout graphs into the ggplot2 ecosystem, giving finer control over aesthetics and allowing the use of ggplot2 themes, scales, and annotations.
set.seed(2024)
ggraph(g_cooc, layout = "fr") +
# edges: width and transparency proportional to PPMI strength
geom_edge_link(aes(width = weight, alpha = weight),
color = "gray60", show.legend = FALSE) +
scale_edge_width(range = c(0.3, 2.5)) +
scale_edge_alpha(range = c(0.2, 0.8)) +
# nodes: coloured by semantic domain
geom_node_point(aes(color = domain), size = 6) +
scale_color_manual(values = domain_cols, name = "Domain") +
# labels with repulsion to avoid overlap
geom_node_label(aes(label = name, color = domain),
repel = TRUE,
size = 3.2,
fontface = "bold",
label.padding = unit(0.15, "lines"),
label.size = 0,
fill = alpha("white", 0.7),
show.legend = FALSE) +
theme_graph(base_family = "sans") +
labs(title = "Conceptual Map: Sense and Sensibility",
subtitle = "Word co-occurrence + PPMI | Fruchterman-Reingold spring layout",
caption = "Edge width ∝ PPMI strength | Colour = semantic domain")
When interpreting a spring-layout conceptual map, look for:
Clusters — groups of tightly connected nodes sharing many strong edges. These correspond to lexical fields or semantic neighbourhoods. In the map above, emotion words (grief, sorrow, pain, distress) should cluster together, as should social-relation words (marriage, friendship, family).
Bridges — nodes that connect two otherwise separate clusters. A bridge word is typically polysemous or semantically broad. In this Austen map, heart and feeling often appear as bridges between the emotion cluster and the social/moral cluster.
Peripheral nodes — words with few strong connections, placed at the edges of the map. These tend to be domain-specific terms that appear in only a narrow range of contexts.
Central nodes — words with many strong connections, placed near the centre. These are typically high-frequency, semantically broad words that act as hubs.
In a co-occurrence conceptual map, what does a high PPMI value between two words indicate?
b) The two words co-occur much more often than expected by chance, suggesting semantic association
PPMI (Positive Pointwise Mutual Information) measures the log ratio of the observed co-occurrence probability to the probability expected if the two words were statistically independent. A high PPMI value means the pair co-occurs far more than chance predicts, which is a strong signal of semantic relatedness — either because they appear in the same semantic frame, describe the same entity, or participate in the same discourse topic. PPMI is not sensitive to syntactic roles (a) and does not measure frequency asymmetry (c) or absence of co-occurrence (d).
What you will learn: How to represent words as TF-IDF vectors across documents, compute cosine similarity between word vectors, and build a conceptual map that reflects topical rather than immediate-context similarity
The co-occurrence approach captures syntagmatic similarity: words that tend to appear near each other. A document-term approach captures paradigmatic similarity: words that tend to appear in the same kinds of documents or text segments, even if not adjacent.
We divide the novel into chapters (treating each chapter as a “document”), compute a TF-IDF matrix, and then compute cosine similarity between the row vectors corresponding to each target word. Two words are similar if they have high TF-IDF weights in the same chapters.
\[\cos(\mathbf{u}, \mathbf{v}) = \frac{\mathbf{u} \cdot \mathbf{v}}{\|\mathbf{u}\| \cdot \|\mathbf{v}\|}\]
Cosine similarity ranges from 0 (orthogonal — no shared context) to 1 (identical context profile).
# Use chapter as the document unit
sns_chapters <- sns |>
dplyr::mutate(
chapter = cumsum(str_detect(text, regex("^chapter", ignore_case = TRUE)))
) |>
dplyr::filter(chapter > 0) |>
tidytext::unnest_tokens(word, text) |>
dplyr::anti_join(stop_words, by = "word") |>
dplyr::filter(str_detect(word, "^[a-z]+$"),
str_length(word) > 2,
word %in% target_words)
# Term frequency per chapter
tfidf_counts <- sns_chapters |>
dplyr::count(chapter, word) |>
tidytext::bind_tf_idf(word, chapter, n)
cat("Unique chapters:", n_distinct(tfidf_counts$chapter), "\n")Unique chapters: 50 cat("Target words with TF-IDF scores:", n_distinct(tfidf_counts$word), "\n")Target words with TF-IDF scores: 36 # Wide matrix: words × chapters
tfidf_wide <- tfidf_counts |>
dplyr::select(word, chapter, tf_idf) |>
tidyr::pivot_wider(names_from = chapter, values_from = tf_idf, values_fill = 0)
# Extract numeric matrix
word_names_tfidf <- tfidf_wide$word
mat_tfidf <- as.matrix(tfidf_wide[, -1])
rownames(mat_tfidf) <- word_names_tfidf
# Cosine similarity: normalise rows then multiply
row_norms <- sqrt(rowSums(mat_tfidf^2))
row_norms[row_norms == 0] <- 1e-10 # avoid division by zero
mat_norm <- mat_tfidf / row_norms
cos_sim <- mat_norm %*% t(mat_norm)
cat("Cosine similarity matrix dimensions:", dim(cos_sim), "\n")Cosine similarity matrix dimensions: 36 36 cat("Range of cosine similarities:", round(range(cos_sim), 3), "\n")Range of cosine similarities: 0 1 # Threshold: keep only strong edges (top 35% of non-diagonal similarities)
cos_vec <- cos_sim[upper.tri(cos_sim)]
thresh <- quantile(cos_vec, 0.65)
# Build edge list
tfidf_edges <- as.data.frame(as.table(cos_sim)) |>
dplyr::rename(from = Var1, to = Var2, weight = Freq) |>
dplyr::filter(as.character(from) < as.character(to), # upper triangle only
weight >= thresh)
g_tfidf <- igraph::graph_from_data_frame(tfidf_edges, directed = FALSE)
# Add domain attribute
dom_tfidf <- domain_lookup$domain[match(V(g_tfidf)$name, domain_lookup$word)]
V(g_tfidf)$domain <- dom_tfidf
set.seed(2024)
ggraph(g_tfidf, layout = "fr") +
geom_edge_link(aes(width = weight, alpha = weight),
color = "gray60", show.legend = FALSE) +
scale_edge_width(range = c(0.3, 2.5)) +
scale_edge_alpha(range = c(0.2, 0.85)) +
geom_node_point(aes(color = domain), size = 6) +
scale_color_manual(values = domain_cols, name = "Domain") +
geom_node_label(aes(label = name, color = domain),
repel = TRUE, size = 3.2, fontface = "bold",
label.padding = unit(0.15, "lines"),
label.size = 0,
fill = alpha("white", 0.7),
show.legend = FALSE) +
theme_graph(base_family = "sans") +
labs(title = "Conceptual Map: Sense and Sensibility",
subtitle = "TF-IDF cosine similarity across chapters | Fruchterman-Reingold layout",
caption = "Edge width ∝ cosine similarity | Colour = semantic domain")
The two maps capture different aspects of semantic relatedness:
Co-occurrence (PPMI): captures local syntagmatic association — words that appear near each other within a few lines. This tends to produce tighter clusters within semantic frames (e.g. grief–sorrow–pain all appearing in scenes of emotional distress).
TF-IDF cosine: captures global paradigmatic association — words that are characteristic of the same chapters or discourse contexts. This tends to produce broader topical groupings (e.g. all words associated with Mrs. Dashwood’s storyline clustering together, regardless of whether they appear adjacent to each other).
Comparing the two maps for the same vocabulary can reveal whether your semantic clusters are driven by immediate collocation or by broader thematic co-occurrence.
A researcher builds a TF-IDF conceptual map of legal vocabulary across 50 court documents. Two terms — “plaintiff” and “defendant” — appear in almost every document with similar TF-IDF weights, but never appear in the same sentence. Where would they be positioned in the map?
b) Close together, because they appear in the same documents with similar TF-IDF profiles
TF-IDF conceptual maps measure similarity based on the document-level distribution of words — which documents or text segments a word tends to be characteristic of. If “plaintiff” and “defendant” both have high TF-IDF values in the same set of court documents (adversarial proceedings rather than regulatory filings), their row vectors in the TF-IDF matrix will be similar, and cosine similarity will be high regardless of whether they co-occur within the same sentence. Option (a) would be correct for a co-occurrence map, but not for a TF-IDF map. Option (c) is incorrect: terms that appear in every document would have low IDF and thus low TF-IDF, but “plaintiff” and “defendant” are typically specific to certain document types.
What you will learn: How to load pre-trained GloVe word vectors, extract vectors for target words, compute cosine similarity, and build a conceptual map that reflects broad distributional semantics trained on large external corpora
Both the co-occurrence and TF-IDF approaches build semantic representations from the corpus at hand — in this case, a single novel. This works well for corpus-internal analysis but means that the quality and coverage of the map depends entirely on the size and diversity of that corpus.
Word embeddings (word2vec, GloVe, fastText) are dense, low-dimensional vector representations trained on billions of words of text. Each word is a point in a 50–300 dimensional space, and the geometry of that space encodes semantic and syntactic relationships: similar words are close together, and relational analogies appear as vector arithmetic (king − man + woman ≈ queen).
For a conceptual map, we extract the embedding vectors for our target words and compute cosine similarity between them. The resulting map reflects the word’s semantic neighbourhood in the broad distributional space — often more stable and linguistically informative than corpus-internal counts for small or domain-specific corpora.
We use the 50-dimensional GloVe vectors (trained on Wikipedia + Gigaword, 6 billion tokens) available from the Stanford NLP Group. The full file is ~170MB; we load only the vectors we need.
# Download GloVe vectors (run once; requires internet access)
# Full file: https://nlp.stanford.edu/data/glove.6B.zip
# After unzipping, load glove.6B.50d.txt
glove_path <- "data/glove.6B.50d.txt" # adjust path as needed
# Read the file — each row is a word followed by 50 float values
glove_raw <- data.table::fread(glove_path, header = FALSE,
quote = "", data.table = FALSE)
colnames(glove_raw) <- c("word", paste0("V", 1:50))
# Extract rows for target words only
glove_target <- glove_raw |>
dplyr::filter(word %in% target_words)
# Save for later reuse
saveRDS(glove_target, "data/glove_target.rds")The GloVe vectors are not bundled with this tutorial because of file size. You can:
text2vec package to train your own GloVe vectors on a corpus of your choice (shown below)# --- Fallback: simulate GloVe-like vectors for illustration ---
# (Replace with real GloVe loading above when running on your own machine)
set.seed(123)
n_words <- length(target_words)
n_dims <- 50
# Simulate vectors with within-domain coherence
glove_sim_mat <- matrix(rnorm(n_words * n_dims), nrow = n_words,
dimnames = list(target_words, paste0("V", 1:n_dims)))
# Inject domain structure: add a shared signal to same-domain words
domain_signals <- list(
Emotion = which(target_words %in% c("love","hope","fear","joy","pain","grief",
"happiness","sorrow","pleasure","affection",
"passion","anxiety","distress")),
Social = which(target_words %in% c("comfort","delight","misery","pride","shame",
"anger","friendship","marriage","family",
"sister","mother")),
Character = which(target_words %in% c("heart","feeling","sensibility","sense",
"honour","duty","beauty","elegance",
"worth","character","spirit","temper"))
)
signal_strength <- 2.5
for (grp in domain_signals) {
shared <- rnorm(n_dims) * signal_strength
glove_sim_mat[grp, ] <- glove_sim_mat[grp, ] + matrix(shared, nrow = length(grp),
ncol = n_dims, byrow = TRUE)
}
glove_target <- as.data.frame(glove_sim_mat) |>
tibble::rownames_to_column("word")# Extract numeric matrix
embed_words <- glove_target$word
embed_mat <- as.matrix(glove_target[, -1])
rownames(embed_mat) <- embed_words
# Cosine similarity
norms <- sqrt(rowSums(embed_mat^2))
norms[norms == 0] <- 1e-10
mat_n <- embed_mat / norms
embed_cos <- mat_n %*% t(mat_n)
cat("Embedding cosine similarity matrix:", dim(embed_cos), "\n")Embedding cosine similarity matrix: 36 36 cat("Similarity range:", round(range(embed_cos), 3), "\n")Similarity range: -0.317 1 # Threshold: keep top 40% of pairwise similarities
ec_vec <- embed_cos[upper.tri(embed_cos)]
ec_thresh <- quantile(ec_vec, 0.60)
embed_edges <- as.data.frame(as.table(embed_cos)) |>
dplyr::rename(from = Var1, to = Var2, weight = Freq) |>
dplyr::filter(as.character(from) < as.character(to),
weight >= ec_thresh)
g_embed <- igraph::graph_from_data_frame(embed_edges, directed = FALSE)
dom_embed <- domain_lookup$domain[match(V(g_embed)$name, domain_lookup$word)]
V(g_embed)$domain <- dom_embed
# Node degree as size proxy
V(g_embed)$degree <- igraph::degree(g_embed)
set.seed(2024)
ggraph(g_embed, layout = "fr") +
geom_edge_link(aes(width = weight, alpha = weight),
color = "gray55", show.legend = FALSE) +
scale_edge_width(range = c(0.2, 2)) +
scale_edge_alpha(range = c(0.15, 0.8)) +
geom_node_point(aes(color = domain, size = degree)) +
scale_color_manual(values = domain_cols, name = "Domain") +
scale_size_continuous(range = c(3, 9), name = "Degree") +
geom_node_label(aes(label = name, color = domain),
repel = TRUE, size = 3, fontface = "bold",
label.padding = unit(0.12, "lines"),
label.size = 0,
fill = alpha("white", 0.75),
show.legend = FALSE) +
theme_graph(base_family = "sans") +
labs(title = "Conceptual Map: Emotion and Social Vocabulary",
subtitle = "GloVe word embedding cosine similarity | Fruchterman-Reingold layout",
caption = "Edge width ∝ cosine similarity | Node size ∝ graph degree | Colour = semantic domain")
A researcher builds a conceptual map using GloVe embeddings trained on Wikipedia. She finds that “sensibility” and “sensitivity” are positioned very close together. A colleague suggests this is a mistake. Who is right, and why?
b) The researcher is right — the words have similar distributional contexts in Wikipedia and their embedding cosines will be high
Word embeddings encode distributional similarity — words that appear in similar contexts across the training corpus. “Sensibility” and “sensitivity” both appear in intellectual, scientific, and literary discourse contexts; both collocate with similar adjectives (heightened, emotional, moral) and appear as subject or object of similar verbs. Their contextual profiles are genuinely similar, which is reflected in their close embedding positions. This is not a mistake — it is a feature: near-synonyms and semantically related words are correctly close in embedding space. The maps are revealing something real about the words’ distributional equivalence in broad English usage, which is exactly what embedding maps are designed to show.
text2vecIf you prefer to train vectors directly on your own corpus rather than using pre-trained ones, text2vec provides a fast, memory-efficient GloVe implementation.
# Train GloVe on Sense and Sensibility using text2vec
# Step 1: create an iterator over the text
corpus_text <- sns |>
dplyr::pull(text) |>
tolower() |>
str_replace_all("[^a-z ]", " ")
tokens_iter <- itoken(corpus_text,
tokenizer = word_tokenizer,
progressbar = FALSE)
# Step 2: build vocabulary (remove rare words)
vocab <- create_vocabulary(tokens_iter) |>
prune_vocabulary(term_count_min = 5)
vectorizer <- vocab_vectorizer(vocab)
# Step 3: build co-occurrence matrix with window = 5
tcm <- create_tcm(itoken(corpus_text, tokenizer = word_tokenizer,
progressbar = FALSE),
vectorizer, skip_grams_window = 5)
# Step 4: fit GloVe (50 dims, 20 iterations)
glove_model <- GlobalVectors$new(rank = 50, x_max = 10)
wv_main <- glove_model$fit_transform(tcm, n_iter = 20, convergence_tol = 0.001)
wv_context <- glove_model$components
# GloVe uses sum of main and context vectors
word_vectors <- wv_main + t(wv_context)
# Extract target words
target_idx <- intersect(target_words, rownames(word_vectors))
embed_custom <- word_vectors[target_idx, ]
cat("Custom GloVe: trained", nrow(embed_custom), "target word vectors\n")Pre-trained (GloVe, word2vec, fastText): - Trained on billions of words — stable, high-coverage representations - Reflect general English usage, not your specific corpus - Best when you want to explore the word’s broad semantic neighbourhood
Corpus-trained: - Reflect the specific register, time period, or domain of your corpus - Require a reasonably large corpus (at least 1–5 million tokens for stable estimates) - Best when you want to explore how meaning is organised within a particular text collection
For small corpora (< 500k tokens), pre-trained embeddings almost always produce better conceptual maps. For large specialised corpora (legal texts, medical records, historical newspapers), corpus-trained embeddings reveal domain-specific semantic structure that general embeddings would miss.
qgraph: Psychometric-Style Conceptual MapsWhat you will learn: How to use qgraph — originally designed for psychometric network analysis — to produce polished weighted-network conceptual maps with additional community detection and edge-filtering options
qgraph?qgraph (Epskamp et al. 2012) was designed for visualising correlation and partial correlation matrices in psychology, but its design maps naturally onto semantic similarity matrices. Key advantages over plain igraph:
qgraph can apply a minimum edge weight threshold (the minimum argument) and prune weak edges cleanlyqgraph Conceptual Map from Co-occurrence SimilaritiesWe use the full PPMI matrix (converted to a symmetric word × word matrix) as direct input to qgraph. It accepts similarity matrices natively.
# Build a full symmetric PPMI matrix for all target words
all_pairs <- tidyr::crossing(w1 = target_words, w2 = target_words) |>
dplyr::filter(w1 < w2) |>
dplyr::left_join(cooc_pmi |> dplyr::select(w1, w2, ppmi),
by = c("w1", "w2")) |>
dplyr::mutate(ppmi = replace_na(ppmi, 0))
ppmi_mat <- matrix(0, nrow = length(target_words), ncol = length(target_words),
dimnames = list(target_words, target_words))
for (i in seq_len(nrow(all_pairs))) {
ppmi_mat[all_pairs$w1[i], all_pairs$w2[i]] <- all_pairs$ppmi[i]
ppmi_mat[all_pairs$w2[i], all_pairs$w1[i]] <- all_pairs$ppmi[i]
}set.seed(2024)
# Node colours by semantic domain
node_color_vec <- dplyr::case_when(
target_words %in% c("love","hope","fear","joy","pain","grief","happiness",
"sorrow","pleasure","affection","passion","anxiety","distress") ~ "#E07B54",
target_words %in% c("comfort","delight","misery","pride","shame","anger",
"friendship","marriage","family","sister","mother") ~ "#5B8DB8",
TRUE ~ "#6BAF7A"
)
qgraph(
ppmi_mat,
layout = "spring",
minimum = 0.05, # suppress very weak edges
maximum = max(ppmi_mat),
cut = 0,
vsize = 8,
labels = target_words,
label.cex = 0.75,
color = node_color_vec,
border.color = "white",
edge.color = "gray60",
posCol = "steelblue",
title = "Conceptual Map (qgraph): Sense and Sensibility PPMI",
mar = c(3, 3, 5, 3)
)
legend("bottomleft",
legend = c("Emotion", "Social", "Character"),
fill = c("#E07B54", "#5B8DB8", "#6BAF7A"),
bty = "n", cex = 0.8, border = "white")
qgraph Key Arguments for Conceptual Maps
| Argument | What it does |
|---|---|
layout = "spring" |
Fruchterman-Reingold spring layout |
minimum |
Suppress edges below this weight (reduces clutter) |
cut |
Edges above cut are drawn as lines; below as curves — useful for distinguishing strong and weak edges |
vsize |
Node size |
color |
Node colours (vector, one per node) |
posCol |
Colour for positive edges |
negCol |
Colour for negative edges (useful for partial correlation maps) |
groups |
Named list of node groups — qgraph colours automatically |
What you will learn: How classical multidimensional scaling (MDS) provides an alternative spatial representation of the same similarity matrix, and how it compares to spring-layout maps
Classical Multidimensional Scaling (cMDS) converts a distance matrix into a two-dimensional spatial arrangement that minimises stress — the discrepancy between the original pairwise distances and the Euclidean distances in the 2D plot. Unlike spring-layout algorithms, MDS is deterministic (no random initialisation) and distance-preserving (the 2D positions faithfully reflect pairwise similarities as closely as possible in two dimensions).
MDS and spring-layout answer slightly different questions:
# Convert PPMI similarity to distance: dist = 1 - sim (after normalising to [0,1])
ppmi_norm <- ppmi_mat / max(ppmi_mat)
ppmi_dist <- as.dist(1 - ppmi_norm)
# Classical MDS using smacof for stress-1 minimisation
set.seed(2024)
mds_result <- smacof::smacofSym(ppmi_dist, ndim = 2, verbose = FALSE)
mds_coords <- as.data.frame(mds_result$conf) |>
tibble::rownames_to_column("word") |>
dplyr::left_join(domain_lookup, by = "word")
cat("MDS Stress-1:", round(mds_result$stress, 3),
"(< 0.10 = good fit; < 0.20 = acceptable)\n")MDS Stress-1: 0.366 (< 0.10 = good fit; < 0.20 = acceptable)ggplot(mds_coords, aes(x = D1, y = D2, color = domain, label = word)) +
geom_point(size = 4) +
scale_color_manual(values = domain_cols, name = "Domain") +
geom_label_repel(size = 3, fontface = "bold",
label.padding = unit(0.15, "lines"),
label.size = 0,
fill = alpha("white", 0.75),
show.legend = FALSE) +
theme_bw() +
labs(
title = "Conceptual Map: MDS Spatial Representation",
subtitle = paste0("Classical MDS on PPMI distances | Stress-1 = ",
round(mds_result$stress, 3)),
x = "MDS Dimension 1",
y = "MDS Dimension 2",
caption = "Position preserves pairwise PPMI distances as faithfully as possible in 2D"
)
The stress-1 value measures how well the 2D MDS solution reproduces the original high-dimensional distances. Kruskal’s rule of thumb:
| Stress-1 | Interpretation |
|---|---|
| < 0.05 | Excellent |
| 0.05–0.10 | Good |
| 0.10–0.20 | Acceptable |
| > 0.20 | Poor — interpret with caution |
High stress means the 2D representation distorts the true distances substantially. In such cases, examining a 3D MDS solution (or switching to t-SNE/UMAP for high-dimensional embedding data) may be warranted.
A researcher produces both a spring-layout conceptual map and an MDS map from the same similarity matrix. The cluster structure looks different in the two maps. Which statement best explains this?
b) Spring layout and MDS optimise different objective functions: spring layout minimises graph energy while MDS minimises the distortion of pairwise distances; the same underlying similarities can produce different spatial arrangements
The two methods are not interchangeable views of the same thing — they optimise fundamentally different criteria. Spring layout (Fruchterman-Reingold) places nodes to minimise a global energy function that balances attractive spring forces and repulsive charges; it emphasises the graph topology and community structure. MDS minimises a stress function that measures how well 2D Euclidean distances match the original similarity distances; it emphasises metric faithfulness. Both maps are correct representations of the same data — they just emphasise different properties. Neither is universally better: spring layout is typically preferred for highlighting clusters and bridges; MDS is preferred when the precise relative distances between words matter.
What you will learn: Systematic strategies for interpreting conceptual maps; how to add community detection, node sizing, and annotation; and practical tips for making publication-quality maps
Community detection algorithms identify clusters of densely interconnected nodes — lexical fields in a semantic map. We use the Louvain algorithm (Hendrickx and Blondel 2008), which is fast and performs well on weighted graphs.
set.seed(2024)
# Run Louvain community detection on the co-occurrence graph
communities <- igraph::cluster_louvain(g_cooc, weights = E(g_cooc)$weight)
# Add community membership to nodes
V(g_cooc)$community <- as.character(membership(communities))
cat("Number of communities detected:", length(communities), "\n")Number of communities detected: 5 cat("Community sizes:", sizes(communities), "\n")Community sizes: 7 5 10 4 7 # Plot with community colouring
community_pal <- RColorBrewer::brewer.pal(max(3, length(communities)), "Set2")
ggraph(g_cooc, layout = "fr") +
geom_edge_link(aes(width = weight, alpha = weight),
color = "gray70", show.legend = FALSE) +
scale_edge_width(range = c(0.3, 2.5)) +
scale_edge_alpha(range = c(0.2, 0.8)) +
# community hull (convex hull shading)
geom_node_point(aes(color = community), size = 6) +
scale_color_brewer(palette = "Set2", name = "Community") +
geom_node_label(aes(label = name),
repel = TRUE, size = 3, fontface = "bold",
label.padding = unit(0.12, "lines"),
label.size = 0,
fill = alpha("white", 0.75)) +
theme_graph(base_family = "sans") +
labs(title = "Conceptual Map with Community Detection",
subtitle = "Louvain algorithm | Colour = detected lexical community",
caption = "Edge width ∝ PPMI | Communities = dense sub-graphs")
Node centrality measures how important a node is in the network. For conceptual maps, high-centrality words are semantic hubs — words that connect many other words and occupy a central position in the semantic space.
# Compute multiple centrality measures
centrality_df <- tibble::tibble(
word = V(g_cooc)$name,
degree = igraph::degree(g_cooc),
strength = igraph::strength(g_cooc, weights = E(g_cooc)$weight),
betweenness = igraph::betweenness(g_cooc, weights = 1 / E(g_cooc)$weight),
eigenvector = igraph::eigen_centrality(g_cooc, weights = E(g_cooc)$weight)$vector
) |>
dplyr::arrange(desc(strength))
centrality_df |>
head(12) |>
dplyr::mutate(across(where(is.numeric), ~round(.x, 2))) |>
flextable() |>
flextable::set_table_properties(width = .85, layout = "autofit") |>
flextable::theme_zebra() |>
flextable::fontsize(size = 11) |>
flextable::set_caption("Top 12 words by weighted degree (strength) in co-occurrence map") |>
flextable::border_outer()word | degree | strength | betweenness | eigenvector |
|---|---|---|---|---|
sorrow | 12 | 27.05 | 216 | 1.00 |
duty | 8 | 16.02 | 86 | 0.60 |
sense | 8 | 13.64 | 55 | 0.58 |
sensibility | 7 | 13.52 | 84 | 0.57 |
elegance | 7 | 12.72 | 34 | 0.37 |
grief | 6 | 12.58 | 32 | 0.55 |
beauty | 6 | 11.53 | 27 | 0.31 |
friendship | 7 | 11.21 | 16 | 0.49 |
spirit | 7 | 10.88 | 60 | 0.30 |
joy | 5 | 10.21 | 67 | 0.32 |
honour | 6 | 9.35 | 13 | 0.23 |
delight | 6 | 9.23 | 11 | 0.36 |
| Measure | What it captures | Linguistic interpretation |
|---|---|---|
| Degree | Number of edges | How many other words this word co-occurs with |
| Strength | Sum of edge weights | Total association weight — overall importance in the network |
| Betweenness | How often on shortest paths | Bridge words: connects otherwise separate clusters |
| Eigenvector | Centrality of neighbours | Connected to other important words — core vocabulary |
High betweenness with moderate degree is the hallmark of a bridge word — a polysemous or cross-domain term that links otherwise distinct semantic fields. In Austen’s vocabulary, heart and feeling often show this pattern, connecting the emotion domain and the social/moral domain.
# Add centrality to graph object
V(g_cooc)$strength <- centrality_df$strength[match(V(g_cooc)$name, centrality_df$word)]
V(g_cooc)$betweenness <- centrality_df$betweenness[match(V(g_cooc)$name, centrality_df$word)]
set.seed(2024)
ggraph(g_cooc, layout = "fr") +
# edges
geom_edge_link(aes(width = weight, alpha = weight),
color = "gray65", show.legend = FALSE) +
scale_edge_width(range = c(0.2, 3)) +
scale_edge_alpha(range = c(0.15, 0.85)) +
# nodes: size = weighted degree (strength), colour = community
geom_node_point(aes(color = community, size = strength)) +
scale_color_brewer(palette = "Set2", name = "Community") +
scale_size_continuous(range = c(3, 12), name = "Strength") +
# labels
geom_node_label(aes(label = name),
repel = TRUE,
size = 3,
fontface = "bold",
label.padding = unit(0.15, "lines"),
label.size = 0,
fill = alpha("white", 0.8)) +
theme_graph(base_family = "sans") +
theme(legend.position = "right",
plot.title = element_text(face = "bold", size = 13),
plot.subtitle = element_text(size = 10, color = "gray40")) +
labs(
title = "Conceptual Map: Emotion and Social Vocabulary in Sense and Sensibility",
subtitle = "Co-occurrence PPMI | Spring layout | Node size ∝ weighted degree | Colour = lexical community",
caption = "Jane Austen (1811) | Context window: 10-line chunks | PPMI threshold: 60th percentile"
)
A word in a conceptual map has high betweenness centrality but only moderate degree. What does this suggest about that word’s role in the semantic network?
c) The word acts as a bridge between otherwise disconnected communities — it is a semantically broad or polysemous connector
Betweenness centrality measures how often a node lies on the shortest path between other pairs of nodes. A word with high betweenness but moderate degree is not directly connected to many words (so its degree is moderate), but the connections it does have bridge otherwise separate clusters — making it a semantic connector or polysemous hub. In a lexical network, such words often belong to multiple semantic fields simultaneously: heart connects body, emotion, and moral character; sense bridges cognitive and social domains. This pattern is linguistically meaningful and warrants close attention when interpreting a conceptual map.
What you will learn: How to avoid common mistakes when constructing and interpreting conceptual maps, and practical guidance on thresholding, vocabulary selection, and reporting
The quality and interpretability of a conceptual map depends critically on vocabulary selection. Some guidelines:
Size: aim for 20–80 target words for a readable map. Fewer than 15 produces an underconnected graph; more than 100 produces a visual hairball even after thresholding.
Frequency: words that appear fewer than 5–10 times in the corpus will have unreliable co-occurrence counts. Filter by minimum frequency before computing PPMI.
Semantic focus: the most informative maps focus on a theoretically motivated vocabulary — a semantic field (emotion words, legal terms, body-part metaphors) rather than arbitrary frequency lists.
Avoid function words: stopword removal is essential. Function words (the, and, is) have high frequency and co-occur with everything, producing meaningless dense connections.
Check coverage: after filtering, confirm that most of your target words appear in the map. Words absent from the corpus entirely will be dropped silently.
Choosing the right similarity threshold is more art than science. The goal is to reveal structure without producing either a disconnected scatter or an unreadable hairball.
# Show maps at three thresholds side by side
thresholds <- c(0.40, 0.60, 0.80)
plots_list <- lapply(thresholds, function(thr) {
thresh_val <- quantile(cooc_pmi$ppmi, thr)
edges_t <- cooc_pmi |>
dplyr::filter(ppmi >= thresh_val) |>
dplyr::select(from = w1, to = w2, weight = ppmi)
g_t <- igraph::graph_from_data_frame(edges_t, directed = FALSE)
V(g_t)$domain <- domain_lookup$domain[match(V(g_t)$name, domain_lookup$word)]
set.seed(2024)
ggraph(g_t, layout = "fr") +
geom_edge_link(color = "gray70", linewidth = 0.5) +
geom_node_point(aes(color = domain), size = 3) +
scale_color_manual(values = domain_cols, guide = "none") +
geom_node_text(aes(label = name), size = 2, repel = TRUE) +
theme_graph(base_family = "sans") +
labs(title = paste0(round((1-thr)*100), "% of pairs retained"),
subtitle = paste0("Threshold: ", round(thr*100), "th percentile"))
})
ggpubr::ggarrange(plotlist = plots_list, ncol = 3, nrow = 1)
A useful heuristic is to choose the threshold at which the largest connected component contains most of your target words but individual clusters are still visually distinguishable. Start at the 50th–65th percentile of your edge weights and adjust until the map is readable. Always report the threshold used.
Before reporting a conceptual map in a publication or presentation:
This tutorial has introduced conceptual maps as a practical, visually rich tool for exploring semantic structure in linguistic data. The key points are:
Three routes to a conceptual map:
| Route | Input | Similarity measure | Best for |
|---|---|---|---|
| Co-occurrence | Raw corpus text | PPMI | Local syntagmatic relations |
| TF-IDF | Corpus divided into documents | Cosine similarity | Topical / register-level relations |
| Word embeddings | Pre-trained or corpus-trained vectors | Cosine similarity | Broad distributional semantics |
Three visualisation approaches:
igraph + ggraph: maximum flexibility, integrates with ggplot2, supports community detection and centrality overlaysqgraph: polished defaults, built-in edge filtering, well-suited to similarity/correlation matricessmacof): distance-preserving alternative, deterministic, good complement to spring-layout mapsKey interpretation principles: clusters = lexical fields; bridges = polysemy or semantic breadth; peripheral nodes = domain-specific vocabulary; node size encodes centrality; edge width encodes similarity strength.
A researcher wants to map how emotion vocabulary is organised in a historical newspaper corpus (1850–1950, 50 million tokens). She has 60 target emotion words. Which combination of approaches would you recommend, and why?
ggraph and community detection overlayc) Co-occurrence PPMI map using the corpus itself, with corpus-trained GloVe embeddings as a comparison; both with ggraph and community detection overlay
50 million tokens is more than sufficient to train stable GloVe embeddings (the rule of thumb is 1–5 million tokens minimum). Corpus-trained embeddings will capture domain-specific historical usage — how Victorian newspapers used emotion vocabulary — which pre-trained modern GloVe would miss (it reflects contemporary English usage). Running both a PPMI co-occurrence map (local collocation patterns) and an embedding map (broader distributional semantics) allows comparison and cross-validation of clusters. ggraph with a community detection overlay is well-suited to 60 nodes. MDS is a useful complement but not a replacement; option (a) is overly restrictive; option (b) is incorrect about the corpus size threshold.
Martin Schweinberger. 2026. Conceptual Maps in R. The Language Technology and Data Analysis Laboratory (LADAL), The University of Queensland, Australia. url: https://ladal.edu.au/tutorials/conceptmaps/conceptmaps.html (Version 3.1.1). doi: 10.5281/zenodo.19332087.
@manual{martinschweinberger2026conceptual,
author = {Martin Schweinberger},
title = {Conceptual Maps in R},
year = {2026},
note = {https://ladal.edu.au/tutorials/conceptmaps/conceptmaps.html},
organization = {The Language Technology and Data Analysis Laboratory (LADAL), The University of Queensland, Australia},
edition = {2026.03.27}
doi = {}
}sessionInfo()R version 4.4.2 (2024-10-31 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows 11 x64 (build 26200)
Matrix products: default
locale:
[1] LC_COLLATE=English_United States.utf8
[2] LC_CTYPE=English_United States.utf8
[3] LC_MONETARY=English_United States.utf8
[4] LC_NUMERIC=C
[5] LC_TIME=English_United States.utf8
time zone: Australia/Brisbane
tzcode source: internal
attached base packages:
[1] stats graphics grDevices datasets utils methods base
other attached packages:
[1] viridis_0.6.5 viridisLite_0.4.2 RColorBrewer_1.1-3 ggrepel_0.9.6
[5] flextable_0.9.11 text2vec_0.6.4 smacof_2.1-7 e1071_1.7-16
[9] colorspace_2.1-1 plotrix_3.8-4 Matrix_1.7-2 widyr_0.1.5
[13] qgraph_1.9.8 ggraph_2.2.1 igraph_2.1.4 gutenbergr_0.2.4
[17] tidytext_0.4.2 lubridate_1.9.4 forcats_1.0.0 stringr_1.5.1
[21] dplyr_1.2.0 purrr_1.0.4 readr_2.1.5 tidyr_1.3.2
[25] tibble_3.2.1 ggplot2_4.0.2 tidyverse_2.0.0
loaded via a namespace (and not attached):
[1] splines_4.4.2 polyclip_1.10-7 rpart_4.1.23
[4] lifecycle_1.0.5 rstatix_0.7.2 Rdpack_2.6.2
[7] doParallel_1.0.17 lattice_0.22-6 vroom_1.6.5
[10] MASS_7.3-61 backports_1.5.0 SnowballC_0.7.1
[13] magrittr_2.0.3 Hmisc_5.2-2 rmarkdown_2.30
[16] yaml_2.3.10 zip_2.3.2 askpass_1.2.1
[19] cowplot_1.2.0 pbapply_1.7-2 minqa_1.2.8
[22] abind_1.4-8 quadprog_1.5-8 nnet_7.3-19
[25] tweenr_2.0.3 float_0.3-2 gdtools_0.5.0
[28] tokenizers_0.3.0 gdata_3.0.1 ellipse_0.5.0
[31] codetools_0.2-20 xml2_1.3.6 ggforce_0.4.2
[34] tidyselect_1.2.1 shape_1.4.6.1 farver_2.1.2
[37] lme4_1.1-36 stats4_4.4.2 base64enc_0.1-6
[40] jsonlite_1.9.0 rsparse_0.5.3 mitml_0.4-5
[43] tidygraph_1.3.1 Formula_1.2-5 survival_3.7-0
[46] iterators_1.0.14 systemfonts_1.3.1 foreach_1.5.2
[49] tools_4.4.2 ragg_1.3.3 Rcpp_1.1.1
[52] glue_1.8.0 mnormt_2.1.1 gridExtra_2.3
[55] pan_1.9 xfun_0.56 withr_3.0.2
[58] fastmap_1.2.0 boot_1.3-31 openssl_2.3.2
[61] digest_0.6.39 timechange_0.3.0 R6_2.6.1
[64] mice_3.19.0 textshaping_1.0.0 gtools_3.9.5
[67] jpeg_0.1-11 weights_1.1.2 RhpcBLASctl_0.23-42
[70] utf8_1.2.4 generics_0.1.3 fontLiberation_0.1.0
[73] renv_1.1.7 data.table_1.17.0 corpcor_1.6.10
[76] class_7.3-22 graphlayouts_1.2.2 htmlwidgets_1.6.4
[79] pkgconfig_2.0.3 gtable_0.3.6 S7_0.2.1
[82] janeaustenr_1.0.0 htmltools_0.5.9 carData_3.0-5
[85] lavaan_0.6-21 fontBitstreamVera_0.1.1 scales_1.4.0
[88] png_0.1-8 wordcloud_2.6 reformulas_0.4.0
[91] lgr_0.4.4 knitr_1.51 rstudioapi_0.17.1
[94] tzdb_0.4.0 reshape2_1.4.4 uuid_1.2-1
[97] checkmate_2.3.2 nlme_3.1-166 nloptr_2.1.1
[100] proxy_0.4-27 cachem_1.1.0 parallel_4.4.2
[103] foreign_0.8-87 mlapi_0.1.1 pillar_1.10.1
[106] grid_4.4.2 vctrs_0.7.1 ggpubr_0.6.0
[109] car_3.1-3 jomo_2.7-6 cluster_2.1.6
[112] htmlTable_2.4.3 evaluate_1.0.3 pbivnorm_0.6.0
[115] cli_3.6.4 compiler_4.4.2 rlang_1.1.7
[118] crayon_1.5.3 ggsignif_0.6.4 labeling_0.4.3
[121] fdrtool_1.2.18 plyr_1.8.9 stringi_1.8.4
[124] psych_2.4.12 nnls_1.6 glmnet_4.1-8
[127] fontquiver_0.2.1 hms_1.1.3 glasso_1.11
[130] patchwork_1.3.0 bit64_4.6.0-1 rbibutils_2.3
[133] broom_1.0.7 memoise_2.0.1 bit_4.5.0.1
[136] officer_0.7.3 polynom_1.4-1 This tutorial was revised and substantially expanded with the assistance of Claude (claude.ai), a large language model created by Anthropic. Claude was used to restructure the document into Quarto format, expand the theoretical introduction, add the new sections and accompanying callouts, expand interpretation guidance across all sections, write the new quiz questions and detailed answer explanations, and produce the comparison summary table. All content was reviewed, edited, and approved by the author (Martin Schweinberger), who takes full responsibility for its accuracy.